const express = require('express');
const router = express.Router();
const { exec } = require('child_process');
const fs = require('fs').promises;
const path = require('path');
const { db } = require('../app');

// 获取用户的服务器列表
router.get('/', (req, res) => {
    if (!req.session.user) {
        return res.status(401).json({ error: '未登录' });
    }

    const userId = req.session.user.id;
    const isAdmin = req.session.user.role === 'admin';

    let query;
    let params;

    if (isAdmin) {
        query = `
            SELECT s.*, u.username as owner_name, n.name as node_name 
            FROM servers s 
            LEFT JOIN users u ON s.user_id = u.id 
            LEFT JOIN nodes n ON s.node_id = n.id
            ORDER BY s.created_at DESC
        `;
        params = [];
    } else {
        query = `
            SELECT s.*, u.username as owner_name, n.name as node_name 
            FROM servers s 
            LEFT JOIN users u ON s.user_id = u.id 
            LEFT JOIN nodes n ON s.node_id = n.id
            WHERE s.user_id = ?
            ORDER BY s.created_at DESC
        `;
        params = [userId];
    }

    db.all(query, params, (err, servers) => {
        if (err) {
            return res.status(500).json({ error: '获取服务器列表失败' });
        }
        res.json({ success: true, servers });
    });
});

// 创建新服务器
router.post('/create', async (req, res) => {
    if (!req.session.user) {
        return res.status(401).json({ error: '未登录' });
    }

    const { name, node_id, server_type, version, port, memory, docker_image } = req.body;

    if (!name || !node_id || !server_type || !version || !port || !memory) {
        return res.status(400).json({ error: '所有字段都是必需的' });
    }

    try {
        // 检查节点是否存在
        db.get('SELECT * FROM nodes WHERE id = ?', [node_id], async (err, node) => {
            if (err) {
                return res.status(500).json({ error: '数据库错误' });
            }
            if (!node) {
                return res.status(400).json({ error: '节点不存在' });
            }

            // 生成服务器配置
            const serverConfig = {
                type: server_type,
                version: version,
                memory: memory,
                port: port,
                docker_image: docker_image || `registry.docker-cn.com/itzg/minecraft-server:${version}`,
                java_version: '17',
                server_properties: {
                    'server-port': port,
                    'motd': `${name} - Minecraft Server`,
                    'max-players': '20',
                    'gamemode': 'survival',
                    'difficulty': 'normal',
                    'spawn-protection': '0',
                    'enable-command-block': 'true'
                }
            };

            // 创建Docker容器
            const containerName = `mc-${req.session.user.username}-${Date.now()}`;
            const dockerCommand = `docker run -d \
                --name ${containerName} \
                -p ${port}:25565 \
                -e EULA=TRUE \
                -e MEMORY=${memory} \
                -e VERSION=${version} \
                -e SERVER_PORT=${port} \
                -v /opt/minecraft-servers/${containerName}:/data \
                ${serverConfig.docker_image}`;

            exec(dockerCommand, async (error, stdout, stderr) => {
                if (error) {
                    console.error('Docker创建失败:', error);
                    return res.status(500).json({ error: '创建服务器失败' });
                }

                const containerId = stdout.trim();

                // 插入数据库
                db.run(
                    'INSERT INTO servers (name, user_id, node_id, docker_container_id, port, status, config) VALUES (?, ?, ?, ?, ?, ?, ?)',
                    [name, req.session.user.id, node_id, containerId, port, 'running', JSON.stringify(serverConfig)],
                    function(err) {
                        if (err) {
                            // 如果数据库插入失败，删除Docker容器
                            exec(`docker rm -f ${containerId}`);
                            return res.status(500).json({ error: '创建服务器失败' });
                        }
                        res.json({ 
                            success: true, 
                            message: '服务器创建成功', 
                            server: { 
                                id: this.lastID, 
                                name, 
                                status: 'running',
                                container_id: containerId 
                            } 
                        });
                    }
                );
            });
        });
    } catch (error) {
        console.error('创建服务器错误:', error);
        res.status(500).json({ error: '服务器错误' });
    }
});

// 启动服务器
router.post('/:id/start', (req, res) => {
    if (!req.session.user) {
        return res.status(401).json({ error: '未登录' });
    }

    const serverId = req.params.id;

    db.get('SELECT * FROM servers WHERE id = ?', [serverId], (err, server) => {
        if (err) {
            return res.status(500).json({ error: '数据库错误' });
        }
        if (!server) {
            return res.status(404).json({ error: '服务器不存在' });
        }

        // 检查权限
        if (req.session.user.role !== 'admin' && server.user_id !== req.session.user.id) {
            return res.status(403).json({ error: '没有权限' });
        }

        // 启动Docker容器
        exec(`docker start ${server.docker_container_id}`, (error, stdout, stderr) => {
            if (error) {
                return res.status(500).json({ error: '启动服务器失败' });
            }

            // 更新状态
            db.run('UPDATE servers SET status = ? WHERE id = ?', ['running', serverId]);
            res.json({ success: true, message: '服务器启动成功' });
        });
    });
});

// 停止服务器
router.post('/:id/stop', (req, res) => {
    if (!req.session.user) {
        return res.status(401).json({ error: '未登录' });
    }

    const serverId = req.params.id;

    db.get('SELECT * FROM servers WHERE id = ?', [serverId], (err, server) => {
        if (err) {
            return res.status(500).json({ error: '数据库错误' });
        }
        if (!server) {
            return res.status(404).json({ error: '服务器不存在' });
        }

        // 检查权限
        if (req.session.user.role !== 'admin' && server.user_id !== req.session.user.id) {
            return res.status(403).json({ error: '没有权限' });
        }

        // 停止Docker容器
        exec(`docker stop ${server.docker_container_id}`, (error, stdout, stderr) => {
            if (error) {
                return res.status(500).json({ error: '停止服务器失败' });
            }

            // 更新状态
            db.run('UPDATE servers SET status = ? WHERE id = ?', ['stopped', serverId]);
            res.json({ success: true, message: '服务器停止成功' });
        });
    });
});

// 重启服务器
router.post('/:id/restart', (req, res) => {
    if (!req.session.user) {
        return res.status(401).json({ error: '未登录' });
    }

    const serverId = req.params.id;

    db.get('SELECT * FROM servers WHERE id = ?', [serverId], (err, server) => {
        if (err) {
            return res.status(500).json({ error: '数据库错误' });
        }
        if (!server) {
            return res.status(404).json({ error: '服务器不存在' });
        }

        // 检查权限
        if (req.session.user.role !== 'admin' && server.user_id !== req.session.user.id) {
            return res.status(403).json({ error: '没有权限' });
        }

        // 重启Docker容器
        exec(`docker restart ${server.docker_container_id}`, (error, stdout, stderr) => {
            if (error) {
                return res.status(500).json({ error: '重启服务器失败' });
            }

            // 更新状态
            db.run('UPDATE servers SET status = ? WHERE id = ?', ['running', serverId]);
            res.json({ success: true, message: '服务器重启成功' });
        });
    });
});

// 删除服务器
router.delete('/:id', (req, res) => {
    if (!req.session.user) {
        return res.status(401).json({ error: '未登录' });
    }

    const serverId = req.params.id;

    db.get('SELECT * FROM servers WHERE id = ?', [serverId], (err, server) => {
        if (err) {
            return res.status(500).json({ error: '数据库错误' });
        }
        if (!server) {
            return res.status(404).json({ error: '服务器不存在' });
        }

        // 检查权限
        if (req.session.user.role !== 'admin' && server.user_id !== req.session.user.id) {
            return res.status(403).json({ error: '没有权限' });
        }

        // 删除Docker容器
        exec(`docker rm -f ${server.docker_container_id}`, (error, stdout, stderr) => {
            if (error) {
                console.error('删除Docker容器失败:', error);
            }

            // 删除服务器数据目录
            const serverDir = `/opt/minecraft-servers/${server.docker_container_id}`;
            exec(`rm -rf ${serverDir}`, (error, stdout, stderr) => {
                if (error) {
                    console.error('删除服务器数据失败:', error);
                }
            });

            // 从数据库删除
            db.run('DELETE FROM servers WHERE id = ?', [serverId], (err) => {
                if (err) {
                    return res.status(500).json({ error: '删除服务器失败' });
                }
                res.json({ success: true, message: '服务器删除成功' });
            });
        });
    });
});

// 获取服务器状态
router.get('/:id/status', (req, res) => {
    if (!req.session.user) {
        return res.status(401).json({ error: '未登录' });
    }

    const serverId = req.params.id;

    db.get('SELECT * FROM servers WHERE id = ?', [serverId], (err, server) => {
        if (err) {
            return res.status(500).json({ error: '数据库错误' });
        }
        if (!server) {
            return res.status(404).json({ error: '服务器不存在' });
        }

        // 检查权限
        if (req.session.user.role !== 'admin' && server.user_id !== req.session.user.id) {
            return res.status(403).json({ error: '没有权限' });
        }

        // 获取Docker容器状态
        exec(`docker inspect --format='{{.State.Status}}' ${server.docker_container_id}`, (error, stdout, stderr) => {
            let status = 'unknown';
            if (!error) {
                status = stdout.trim();
            }

            res.json({ 
                success: true, 
                status: status,
                server: {
                    id: server.id,
                    name: server.name,
                    port: server.port,
                    created_at: server.created_at
                }
            });
        });
    });
});

// 获取服务器日志
router.get('/:id/logs', (req, res) => {
    if (!req.session.user) {
        return res.status(401).json({ error: '未登录' });
    }

    const serverId = req.params.id;
    const lines = parseInt(req.query.lines) || 100;

    db.get('SELECT * FROM servers WHERE id = ?', [serverId], (err, server) => {
        if (err) {
            return res.status(500).json({ error: '数据库错误' });
        }
        if (!server) {
            return res.status(404).json({ error: '服务器不存在' });
        }

        // 检查权限
        if (req.session.user.role !== 'admin' && server.user_id !== req.session.user.id) {
            return res.status(403).json({ error: '没有权限' });
        }

        // 获取Docker容器日志
        exec(`docker logs --tail ${lines} ${server.docker_container_id}`, (error, stdout, stderr) => {
            if (error) {
                return res.status(500).json({ error: '获取日志失败' });
            }

            res.json({ 
                success: true, 
                logs: stdout.split('\n').filter(line => line.trim())
            });
        });
    });
});

// 执行服务器命令
router.post('/:id/command', (req, res) => {
    if (!req.session.user) {
        return res.status(401).json({ error: '未登录' });
    }

    const serverId = req.params.id;
    const { command } = req.body;

    if (!command) {
        return res.status(400).json({ error: '命令不能为空' });
    }

    db.get('SELECT * FROM servers WHERE id = ?', [serverId], (err, server) => {
        if (err) {
            return res.status(500).json({ error: '数据库错误' });
        }
        if (!server) {
            return res.status(404).json({ error: '服务器不存在' });
        }

        // 检查权限
        if (req.session.user.role !== 'admin' && server.user_id !== req.session.user.id) {
            return res.status(403).json({ error: '没有权限' });
        }

        // 执行命令
        exec(`docker exec ${server.docker_container_id} rcon-cli ${command}`, (error, stdout, stderr) => {
            if (error) {
                return res.status(500).json({ error: '执行命令失败' });
            }

            res.json({ 
                success: true, 
                message: '命令执行成功',
                output: stdout
            });
        });
    });
});

module.exports = router;